let websock = null;
const messageCallback = null;
const errorCallback = null;
const wsUrl = 'ws://121.196.217.190:8080/wx/v1/im/ws';
let heartCheckInterval = null; // 用于存储心跳定时器；
let ReconnectionInterval = null; // 用于存储重连定时器
let tryTime = 0; // 断线重连的次数
const degree = 0; // 数据监听初始化次数

import { loginStore } from '../store/index';
import WsStore from '../store/modules/ws.js';
const useloginStore = loginStore();
const token = `Bearer ${useloginStore.profile}`;


// // 存储聊天记录
// function saveChatRecord(userId1, userId2, message) {
// 	const fileName = `chat_${userId1}_${userId2}.json`;
// 	console.log(fileName);
// 	const chat = `chat_${userId1}_${userId2}`;
// 	const chatContent = uni.getStorageSync(fileName) || '{"chatHistory": {}}';
// 	const chatRecords = JSON.parse(chatContent);
// 	if (!chatRecords.chatHistory.hasOwnProperty(chat)) {
// 		chatRecords.chatHistory[chat] = [];
// 	}
// 	// 将新消息追加到聊天记录数组中
// 	chatRecords.chatHistory[chat].push(message);
// 	uni.setStorageSync(fileName, JSON.stringify(chatRecords));
// 	console.log(JSON.stringify(chatRecords));
// 	console.log('聊天记录存好了');
// }

// 检测到错误，重新链接并把消息保存本地
const errorDetected = (agentData) => {
	const wsstore = WsStore();
	// 把刚才的数据存为错误保存到本地
	agentData.Status = false;
	uni.setStorageSync('agentData.Status', false);
	// if (agentData.user_id1 && agentData.user_id2) {
	// 	saveChatRecord(agentData.user_id1, agentData.user_id2, agentData);
	// }
	// 更新服务器响应
	wsstore.WsChat = agentData;
};


// 建立链接
export function foundWebSocket() {
	const wsstore = WsStore();
	// 关闭链接
	uni.closeSocket();
	// 设置为空s
	websock = null;
	// 关闭链接提示
	uni.hideLoading();
	websock = uni.connectSocket({
		url: wsUrl,
		header: {
			Authorization: token,
		},
		success: () => {
			// 网络正常，不显示
			console.log('网络正常');
			wsstore.network = false;
			// websocketSend({
			// 	id: usestore.chatRoom,
			// });
		},
	});
}

// 初始化weosocket
export function initWebSocket() {
	// degree++; // 每次进行链接增长次数
	// 建立链接
	foundWebSocket();
	// if (degree <= 1) {
	// 只让他执行一次
	uni.onSocketOpen((res) => {
		console.log('WebSocket连接已打开！');
		// 关闭重连
		// clearInterval(ReconnectionInterval);
		// 打开心跳检测
		// startHeartbeat();
	});
	uni.onSocketMessage((e) => {
		// 接收响应数据
		// websocketonmessage(e);
	});
	uni.onSocketError((res) => {
		console.log('WebSocket连接打开失败，请检查！');
		// 连接关闭时停止心跳检测；
		stopHeartbeat();
		// 监测到关闭，进行重连
		websocketclose(res);
	});
	uni.onSocketClose((res) => {
		console.log('WebSocket 已关闭！');
		stopHeartbeat(); // 连接关闭时停止心跳检测
		// // 监测到关闭，进行重连
		websocketclose(res);
	});
}


// 关闭ws连接,进行重连
function websocketclose(e) {
	const wsstore = WsStore();
	// 网络不正常，显示
	wsstore.network = true;

	// 重置链接次数
	tryTime = 0;
	// e.code === 1000  表示正常关闭。 无论为何目的而创建, 该链接都已成功完成任务。
	// e.code !== 1000  表示非正常关闭。
	if (e && e.code !== 1000) {
		console.log('ws连接关闭');
		// // 如果需要设置异常重连
		if (ReconnectionInterval) {
			clearInterval(ReconnectionInterval);
		}
		ReconnectionInterval = setInterval(() => {
			tryTime++;
			// 展示重连次数
			uni.showLoading({
				title: `第${tryTime}次链接`,
			});
			uni.getNetworkType({
				complete(res) {
					if (res.networkType !== 'none') {
						// 关闭定时器
						clearInterval(ReconnectionInterval);
						// 建立链接
						foundWebSocket();
						// 关闭链接提示
						uni.hideLoading();
						// 网络正常，不显示
						wsstore.network = false;
					}
				},
			});

			if (tryTime > 7) {
				// 关闭重连
				clearInterval(ReconnectionInterval);
				// 关闭链接提示
				uni.hideLoading();
				// 信息提示
				uni.showToast({
					icon: 'error',
					title: '请退出重进!!',
				});
			}
		}, 8000);
	}
}

// // 处理后端传来的消息存在本地
// const wsMessage = (data) => {
// 	const wsstore = WsStore();
// 	// 将信息存储到本地，用于更新消息
// 	wsstore.WsChat = data;
// 	data.Status = true;
// 	saveChatRecord(data.user_id1, data.user_id2, data);
// };


// // 接收ws后端返回的数据
// function websocketonmessage(e) {
// 	console.log(e.data, '接收后端返回的数据');
// 	wsMessage(JSON.parse(e.data));
// }

/**
 * websocket发送数据
 * @param {Object} agentData 需要向后台传递的参数数据
 */
export function websocketSend(agentData) {
	console.log('发送的数据', agentData);
	const wsstore = WsStore();
	// 将信息存储到本地，用于更新消息
	// 加延迟是为了尽量让ws连接状态变为OPEN
	setTimeout(() => {
		if (websock) {
			// 添加状态判断，当为OPEN时，发送消息

			if (websock.readyState === websock.OPEN) { // websock.OPEN = 1
				const sentData = {
					type: 1,
					message: {
						user_id1: agentData.user_id1.toString(),
						user_id2: agentData.user_id2,
						content: agentData.Content,
					},
				};

				// 发给后端的数据需要字符串化
				uni.sendSocketMessage({
					data: JSON.stringify(sentData),
					success: () => {
						console.log('发送成功');
						agentData.Status = true;
						uni.setStorageSync('agentData.Status', true);
						// saveChatRecord(agentData.user_id1, agentData.user_id2, agentData);
						wsstore.WsChat = agentData;
					},
					fail: () => {
						// 调用发送失败保存本地方法
						errorDetected(agentData);
					},
				});
			}
			if (websock.readyState === websock.CLOSED) { // websock.CLOSED = 3
				console.log('websock.readyState=3', 'ws连接异常，请稍候重试');
				// 重新建立链接
				foundWebSocket();
				// 调用发送失败保存本地方法
				errorDetected(agentData);
			}
		} else {
			// 重新建立链接
			foundWebSocket();
			// 调用发送失败保存本地方法
			errorDetected(agentData);
		}
	}, 800);
}

/**
 * 关闭websocket函数
 */
export function closeWebsocket() {
	console.log('关闭链接');
	uni.closeSocket();
}
// 开始心跳检测s
function startHeartbeat() {
	const wsstore = WsStore();
	const sentData = {
		user_id1: '',
		user_id2: '',
		content: '',
		Status: null,
	};
	if (heartCheckInterval) {
		clearInterval(heartCheckInterval);
	}
	heartCheckInterval = setInterval(() => {
		uni.getNetworkType({
			complete(res) {
				// || res.networkType == "unknown"
				if (res.networkType == 'none') {
					// 网断开关闭心跳检测
					stopHeartbeat();
					console.log(res.networkType, '网络不好关闭心跳检测');
					// 网络不正常，显示
					wsstore.network = true;
				} else {
					// 发送数据
					websocketSend(sentData);
					console.log(res.networkType, '正在心跳检测');
					// 网络正常，不显示
					wsstore.network = false;
				}
			},
		});
	}, 10000); // 每隔10秒发送一次心跳消息，你可以根据需要调整间隔时间
}

// 停止心跳检测
function stopHeartbeat() {
	clearInterval(heartCheckInterval);
}
